"""
Vistas utilizadas
"""
from pyramid.response import Response
from pyramid.renderers import render
import json
import re
from pyramid.httpexceptions import HTTPFound, HTTPNotFound
from pyramid.security import authenticated_userid
from sqlalchemy import and_
from sqlalchemy import or_
from alpha.modelos import DBSession
from alpha.modelos.models import Usuario
from alpha.modelos.models import Rol
from alpha.modelos.models import Proyecto
from alpha.modelos.models import Permiso
from alpha.modelos.models import Item
from alpha.modelos.models import RelacionSucesor
from alpha.modelos.models import RelacionHijo
from alpha.modelos.models import AsociacionRolPermiso
from alpha.modelos.models import AsociacionUsuarioRol
from alpha.modelos.models import AsociacionFaseTipoItem
from alpha.modelos.models import AsociacionRolProyecto
from alpha.modelos.models import AsociacionRolFase
from alpha.modelos.models import AsociacionRolTipoItem
from alpha.modelos.models import TipoItem
from alpha.modelos.models import Historial
from alpha.modelos.models import Atributo
from alpha.modelos.models import Fase
import transaction


def listarUsuarios(request):
	""" Funcion que lista los usuarios registrados en el sistema 
	:return: retorna una diccionario con todos los usuarios del sistema"""
	session = DBSession()
	lista= []
	for instance in session.query(Usuario).order_by(Usuario.nombre): 
		var= dict(id= instance.id, nombreUsuario=instance.nombreUsuario, nombre= instance.nombre, apellido= instance.apellido, 
		telefono=instance.telefono, nroDocumento=instance.nroDocumento, email= instance.mail, fecha = instance.fechaCreacion.strftime("%d-%m-%Y %H:%M:%S"))
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def buscar_usuarios(request):
	""" Funcion que lista los usuarios registrados en el sistema 
	:return: retorna una diccionario con todos los usuarios del sistema"""
	session = DBSession()
	lista= []
	nombreUsuario= request.matchdict['nombreUsuario'] 
	nombre= request.matchdict['nombre']
	apellido= request.matchdict['apellido']
	telefono= int(request.matchdict['telefono'])
	nroDocumento= int(request.matchdict['nroDocumento'])
	email= request.matchdict['email']
	fecha= request.matchdict['fechaCreacion']
	dividir= email.split('%40')
	if len(dividir) == 2:
		email= str(dividir[0]) + '@'+ str(dividir[1])
	usuarios_sistema= session.query(Usuario).all()
	for instance in usuarios_sistema:
		if instance.getNombre() == nombre or instance.getNombreUsuario() == nombreUsuario or instance.getApellido() == apellido or instance.getTelefono() == telefono or instance.getNroDocumento() == nroDocumento or instance.getMail() == email or instance.getFecha() == fecha:
			var= dict(id= instance.id, nombreUsuario=instance.nombreUsuario, nombre= instance.nombre, apellido= instance.apellido, 
			telefono=instance.telefono, nroDocumento=instance.nroDocumento, email= instance.mail, fecha = instance.fechaCreacion.strftime("%d-%m-%Y %H:%M:%S"))
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def buscar_proyectos(request):
	""" Funcion que lista los proyectos del sistema 
	:return: retorna una diccionario con todos proyectos del sistema"""
	session = DBSession()
	lista= []
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	lista_proyectos_roles= []
	"""
	saca los proyectos en donde tiene el rol desarrollador o administrador de fase
	"""
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionProyecto:
			proyecto= relacion.proyecto
			if not(proyecto in lista_proyectos_roles):
				lista_proyectos_roles.append(proyecto)
	"""
	saca los proyectos en los cuales es lider
	"""
	for proyecto in usuario.liderProyecto:
		if not(proyecto in lista_proyectos_roles):
			lista_proyectos_roles.append(proyecto)
	nombre= request.matchdict['nombre']
	nroFases= int(request.matchdict['nroFases'])
	fechaCreacion= request.matchdict['fechaCreacion']
	estado= request.matchdict['estado']
	busqueda= []
	for candidato in lista_proyectos_roles:
		if candidato.getNombre() == nombre or candidato.getNroFases() == nroFases or candidato.getEstado() == estado or candidato.getFecha() == fechaCreacion:
			busqueda.append(candidato)
	for instance in busqueda:
		var= dict(id= instance.id, nombre=instance.getNombre(), descripcion=instance.getDescripcion(), nroFases=instance.getNroFases() ,fecha = instance.fechaCreacion.strftime("%d-%m-%Y %H:%M:%S"), estado = instance.getEstado())
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def buscar_tipo_items_por_proyecto(request):
	session = DBSession()
	lista= []
	id_Proyecto = int(request.matchdict['id_proyecto'])
	proyecto= session.query(Proyecto).filter_by(id = id_Proyecto).first()
	nombre= request.matchdict['nombre']
	nroAtributos= int(request.matchdict['nroAtributos'])
	###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	lista_tipos_roles= []
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	######
	for tipo_item in lista_tipos_roles:
		if tipo_item.getNombre() == nombre or tipo_item.getNroAtributos() == nroAtributos:
			var= dict(id= tipo_item.id, idProyecto = id_Proyecto, nombre= tipo_item.getNombre(), descripcion= tipo_item.getDescripcion(), 
			nroAtributos= tipo_item.getNroAtributos())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


#Esta funcion se usa en el "drag and drop de usuarios" en la "seccion roles" en el grid derecho para listar los usuarios que estan asignados a un id_rol pasado como parametro a la vista
def listarUsuarios_Rol(request):
	""" Funcion que lista los usuarios que estan asignados a un rol determinado 
	:return: retorna una diccionario con los usuarios que estan asignado al rol """
	session = DBSession()
	"""note: aca quitamos el id del rol del request para buscar los usuarios asociados a ese rol"""
	id_rol = request.matchdict['idRol'] 
	"""note: lista de asociaciones que apuntan a usuarios que poseen este rol"""
	listaDeRelacionados=  session.query(AsociacionUsuarioRol).filter_by(right_id= id_rol).all() 
	"""var lista: lista de usuarios que poseen este rol"""
	lista= []
	for asociacion in listaDeRelacionados:
		"""note: busca los usuarios por medio de los ids"""
		usuario= session.query(Usuario).filter_by( id= asociacion.left_id ).first() 
		var= dict( nombreUsuario= usuario.getNombreUsuario() )
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


#Esta funcion se usa en el "drag and drop de usuarios" en la "seccion roles" en el grid izquierdo para listar los usuarios que no estan asignados a un id_rol pasado como parametro a la vista
def listarNoUsuarios_Rol(request):
	""" Funcion que lista los usuarios que no estan asignados a un rol determinado 
	:return: retorna un diccionario con los usuarios que no estan asignado al rol """
	session = DBSession()
	"""note: aca quitamos el id del rol del request para buscar los usuarios asociados a ese rol"""
	id_rol = request.matchdict['idRol'] 
	"""note: consulta el id de todos los usuarios que tiene ese rol"""
	listaDeRelacionados=  session.query(AsociacionUsuarioRol).filter_by(right_id= id_rol).all() 
	"""var lista: Lista finales de usuarios que no tiene el rol"""
	lista= []
	"""var listaUsuariosRol: lista de usuarios que si poseen este rol"""
	listaUsuariosRol= []
	"""var listaTodosLosUsuarios: lista de todos los usuarios del sistema"""
	listaTodosLosUsuarios= []
	for asociacion in listaDeRelacionados:
		"""note: busca los usuarios por medio de los ids"""
		usuario= session.query(Usuario).filter_by( id= asociacion.left_id ).first()
		listaUsuariosRol.append(usuario)
	for instance in session.query(Usuario).order_by(Usuario.id):
		listaTodosLosUsuarios.append(instance)
	for candidato in listaTodosLosUsuarios:
		if(not(candidato in listaUsuariosRol)):
			var= dict( nombreUsuario= candidato.getNombreUsuario() )
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


#Esta funcion se usa en el "drag and drop de roles" en la "seccion roles" en el grid derecho para listar los roles que estan asignados a un id_usuario pasado como parametro a la vista
def listarRoles_Usuario(request):
	session= DBSession()
	id_usuario = int(request.matchdict['idUsuario'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles asociados con dicho usuario
	lista= []
	usuario= session.query(Usuario).filter_by(id= id_usuario).first()
	for asociacion in usuario.asociacionRol:
		instance= asociacion.rol
		var= dict(nombreRol=instance.getNombre())
		lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


#Esta funcion se usa en el "drag and drop de roles" en la "seccion roles" en el grid derecho para listar los roles que no estan asignados a un id_usuario pasado como parametro a la vista
def listarNoRoles_Usuario(request):
	session= DBSession()
	id_usuario = int(request.matchdict['idUsuario'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles que no estan asociados con dicho usuario
	lista_vista= []
	lista_roles= []
	lista= []
	usuario= session.query(Usuario).filter_by(id= id_usuario).first()
	for asociacion in usuario.asociacionRol:
		instance= asociacion.rol
		lista_vista.append(instance)
	for roles in session.query(Rol).order_by(Rol.id):
		lista_roles.append(roles)
	for rol in lista_roles:
		if not(rol in lista_vista):
			var= dict(nombreRol= rol.getNombre())
			lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarRoles(request):
	""" Funcion que lista los roles del sistema 
	:return: retorna una diccionario con todos roles del sistema"""
	session= DBSession()
	lista= []
	for instance in session.query(Rol).order_by(Rol.nombre): 
		var= dict(id=instance.id, nombreRol=instance.getNombre(),tipoRol= instance.getTipo(), descripcion=instance.getDescripcion(), fecha = instance.fechaCreacion.strftime("%d-%m-%y %H:%M:%S"))
		lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarProyectos(request):
	""" Funcion que lista los proyectos del sistema 
	:return: retorna una diccionario con todos proyectos del sistema"""
	session = DBSession()
	lista= []
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	lista_proyectos_roles= []
	"""
	saca los proyectos en donde tiene el rol desarrollador o administrador de fase
	"""
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionProyecto:
			proyecto= relacion.proyecto
			if not(proyecto in lista_proyectos_roles):
				lista_proyectos_roles.append(proyecto)
	"""
	saca los proyectos en los cuales es lider
	"""
	for proyecto in usuario.liderProyecto:
		if not(proyecto in lista_proyectos_roles):
			lista_proyectos_roles.append(proyecto)
	#session.query(Proyecto).order_by(Proyecto.nombre)
	for instance in lista_proyectos_roles:
			var= dict(id= instance.id, nombre=instance.getNombre(), descripcion=instance.getDescripcion(), 
			nroFases=instance.getNroFases() ,fecha = instance.fechaCreacion.strftime("%d-%m-%Y %H:%M:%S"), estado = instance.getEstado())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listarTipoRol(request):
	lista= [{'tipoRol':'LiderProyecto'}, {'tipoRol':'LiderFase'}, {'tipoRol':'Desarrollador'},{'tipoRol':'Administrador'},{'tipoRol':'Ninguno'}]
	output = json.dumps({'data':lista})
	return Response(output)


def listarTipoAtributo(request):
	lista= [{'tipoAtributo':'String'}, {'tipoAtributo':'Integer'}, {'tipoAtributo':'Date'}]
	output = json.dumps({'data':lista})
	return Response(output)


def listarNoPermisos_Rol(request):
	session= DBSession()
	id_rol = int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles que no estan asociados con dicho usuario
	lista_vista= []
	lista_permisos= []
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionPermiso:
		instance= asociacion.permiso
		lista_vista.append(instance)
	for permiso in session.query(Permiso).order_by(Permiso.id):
		lista_permisos.append(permiso)
	for permiso in lista_permisos:
		if not(permiso in lista_vista):
			var= dict(nombrePermiso= permiso.getNombre())
			lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarNoProyectos_Rol(request):
	session= DBSession()
	id_rol = int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles que no estan asociados con dicho usuario
	lista_vista= []
	lista_proyecto= []
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionProyecto:
		instance= asociacion.proyecto
		lista_vista.append(instance)
	for proyecto in session.query(Proyecto).order_by(Proyecto.id):
		lista_proyecto.append(proyecto)
	for proyecto in lista_proyecto:
		if not(proyecto in lista_vista):
			var= dict(id= proyecto.id, nombreProyecto= proyecto.getNombre())
			lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarProyectos_Rol(request):
	session= DBSession()
	id_rol= int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles asociados con dicho usuario
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionProyecto:
		instance= asociacion.proyecto
		var= dict(id= instance.id, nombreProyecto=instance.getNombre())
		lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarPermisos_Rol(request):
	session= DBSession()
	id_rol= int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles asociados con dicho usuario
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionPermiso:
		instance= asociacion.permiso
		var= dict(nombrePermiso=instance.getNombre())
		lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarFases_Rol(request):
	session= DBSession()
	id_rol= int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles asociados con dicho usuario
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionFase:
		instance= asociacion.fase
		proyecto= session.query(Proyecto).filter_by(id= instance.proyecto_id).first()
		var= dict(id= instance.id, nombreFase= proyecto.getNombre() +" - "+instance.getNombre())
		lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarTipoItem_Rol(request):
	session= DBSession()
	id_rol= int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles asociados con dicho usuario
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionTipoItem:
		instance= asociacion.tipoItem
		proyecto= session.query(Proyecto).filter_by(id= instance.proyecto_id).first()
		var= dict(id= instance.id, nombreTipoItem= proyecto.getNombre() +" - "+instance.getNombre())
		lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarNoTipoItem_Rol(request):
	session= DBSession()
	id_rol = int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles que no estan asociados con dicho usuario
	lista_vista= []
	lista_tipoItem= []
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionTipoItem:
		instance= asociacion.tipoItem
		lista_vista.append(instance)
	for proyecto_rol in rol.asociacionProyecto:
		for tipo in proyecto_rol.proyecto.tipoItems:
			lista_tipoItem.append(tipo)
	for tipo in lista_tipoItem:
		if not(tipo in lista_vista):
			proyecto= session.query(Proyecto).filter_by(id= tipo.proyecto_id).first()
			var= dict(id= tipo.id, nombreTipoItem= proyecto.getNombre() +" - "+tipo.getNombre())
			lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarNoFases_Rol(request):
	session= DBSession()
	id_rol = int(request.matchdict['idRol'])#aca sacamos el id de usuario que se pasa como parametro para buscar los roles que no estan asociados con dicho usuario
	lista_vista= []
	lista_fase= []
	lista= []
	rol= session.query(Rol).filter_by(id= id_rol).first()
	for asociacion in rol.asociacionFase:
		instance= asociacion.fase
		lista_vista.append(instance)
	for proyecto_rol in rol.asociacionProyecto:
		for fase in proyecto_rol.proyecto.fases:
			lista_fase.append(fase)
	for fase in lista_fase:
		if not(fase in lista_vista):
			proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first()
			var= dict(id= fase.id, nombreFase= proyecto.getNombre() +" - "+fase.getNombre())
			lista.append(var)
	output= json.dumps({'data':lista})
	return Response(output)


def listarPermisos_Logueado(request):
	session= DBSession()
	en_linea= authenticated_userid(request)# obtiene el "username" del usuario logueado actualmente
	lista_roles= []
	lista_permisos= []
	lista=[]
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	output = json.dumps({'success': True,'data': '{relleno}'})# Se debe corroborar si esta correcto este valor ficticio !!!!!!!!!!!!!!!!!!!!
	if usuario != None:
		for asoRol in usuario.asociacionRol:
			instance= asoRol.rol
			lista_roles.append(instance)# lsita de roles del usuario
		for rol in lista_roles:
			for asoPermiso in rol.asociacionPermiso:
				if not(asoPermiso.permiso in lista_permisos):# si el permiso no se encuentra en la lista a mandar a la vista, se anhade
					lista_permisos.append(asoPermiso.permiso)
		for permiso in lista_permisos:# inclui este for para que sea mas legible, aunque no hace falta, de paso da el formato del json
			lista.append('{'+permiso.getNombre()+'}')
		cadena= ",".join(lista)
		cadena= "{relleno}, "+ cadena
		output= json.dumps({'success': True,'data': cadena})
	return Response(output)


def listarUsuarios_conRolLider(request):
	session = DBSession()
	lista= []
	id_proyecto = request.matchdict['id_proyecto']
	proyecto=  session.query(Proyecto).filter_by(id= id_proyecto).first()# proyecto en cuestion
	lider_actual= session.query(Usuario).filter_by(id = proyecto.lider_id).first()# usuario que es lider de proyecto
	roles_tipo_lideres= session.query(Rol).filter_by(tipo = 'LiderProyecto').all()# id del rol 'Lider de proyecto'
	usuarios_lideres= []
	for usuario in session.query(Usuario).all():
		for relacion in usuario.asociacionRol:
			if (relacion.rol in roles_tipo_lideres) and usuario !=lider_actual and not(usuario in usuarios_lideres):
				print "\n\n\n\n"
				print usuario.getNombreUsuario()
				print "\n\n\n\n"
				usuarios_lideres.append(usuario)
	for aux in usuarios_lideres:
		var= dict( nombreUsuario= aux.getNombreUsuario())
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def mostrarLider_actual(request):
	session = DBSession()
	lista= []
	id_proyecto = request.matchdict['id_proyecto']
	proyecto=  session.query(Proyecto).filter_by(id= id_proyecto).first()# proyecto en cuestion
	usuario= session.query(Usuario).filter_by(id = proyecto.lider_id).first()# usuario que es lider de proyecto
	if usuario != None:
		var= dict( nombreUsuario= usuario.getNombreUsuario())
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listarAtributos_tipoItem(request):
	session = DBSession()
	lista= []
	id_tipo = request.matchdict['id_tipoItem']
	tipo=  session.query(TipoItem).filter_by(id= id_tipo).first()
	if tipo != None:
		for atributo in tipo.atributos:
			var= dict( id= atributo.id, nombreAtributo= atributo.getNombre(), valor= atributo.getValor(), tipo= atributo.getTipo(), 
			descripcion= atributo.getDescripcion())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listarAtributos_Item(request):
	session = DBSession()
	lista= []
	idItem = request.matchdict['idItem']
	item=  session.query(Item).filter_by(id= idItem).first()
	if item != None:
		for atributo in item.atributos:
			var= dict( id= atributo.id, nombreAtributo= atributo.getNombre(), valor= atributo.getValor(), tipo= atributo.getTipo(), 
			descripcion= atributo.getDescripcion())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_tipo_items_por_proyecto(request):
	session = DBSession()
	lista= []
	id_Proyecto = int(request.matchdict['id_proyecto'])
	proyecto= session.query(Proyecto).filter_by(id = id_Proyecto).first()
	###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	lista_tipos_roles= []
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	######
	for tipo_item in lista_tipos_roles:
		var= dict(id= tipo_item.id, idProyecto = id_Proyecto, nombre= tipo_item.getNombre(), descripcion= tipo_item.getDescripcion(), 
		nroAtributos= tipo_item.getNroAtributos())
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_no_tipo_items_por_proyecto(request):
	session = DBSession()
	lista= []
	lista_vista= []
	lista_excluidos= []
	id_Proyecto = request.matchdict['id_proyecto']
	proyecto= session.query(Proyecto).filter_by(id = id_Proyecto).first()
	if proyecto != None:
		for tipo_item in proyecto.tipoItems:
			lista_vista.append(tipo_item)
		for tipo_item in session.query(TipoItem).all():
			if not (tipo_item in lista_vista):
				lista_excluidos.append(tipo_item)
		for tipo_item in lista_excluidos:
			proyecto= session.query(Proyecto).filter_by(id = tipo_item.proyecto_id).first()
			var= dict(id= tipo_item.id, nombreTipoItem= proyecto.getNombre() + " - " + tipo_item.getNombre())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_fases_por_proyecto(request):
	session = DBSession()
	lista= []
	lista_fases_roles= []
	id_Proyecto = request.matchdict['id_proyecto']
	proyecto= session.query(Proyecto).filter_by(id = id_Proyecto).first()
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	"""
	note: agrega a la lista todas las fases si el usuario es lider de ese proyecto
	"""
	if proyecto in usuario.liderProyecto:
		for fase in proyecto.fases:
			lista_fases_roles.append(fase)
	"""
	note: agrega las fases correspondientes al proyecto que se encuentra en algun rol del usuario
	"""
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionFase:
			fase= relacion.fase
			""" si la fase no ha sido anhadida y corresponde al proyecto"""
			if not(fase in lista_fases_roles) and (fase in proyecto.fases):
				lista_fases_roles.append(fase)
	if proyecto != None:
		for fase in lista_fases_roles:
			print "\n\n\n\n\n"
			print fase.getNroItems()
			print "\n\n\n\n\n"
			var= dict(id= fase.id, nombreFase= fase.getNombre(), descripcion= fase.getDescripcion(), posicionFase= fase.getPosicionFase(), 
			nroItems= fase.getNroItems(), nroLBs= fase.getNroLB(), estado= fase.getEstado(), idProyectoFase= fase.proyecto_id)
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_tipo_items_por_fase(request):
	session = DBSession()
	lista= []
	id_fase= request.matchdict['id_fase']
	fase= session.query(Fase).filter_by(id= id_fase).first()
	if fase != None:
		proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first()
		###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
		en_linea= authenticated_userid(request)
		usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
		lista_tipos_roles= []
		if usuario.esLider(proyecto):
			for tipoItem in proyecto.tipoItems:
				lista_tipos_roles.append(tipoItem)
		for asociacion in usuario.asociacionRol:
			rol= asociacion.rol
			for relacion in rol.asociacionTipoItem:
				tipoItem= relacion.tipoItem
				if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
					lista_tipos_roles.append(tipoItem)
		######
		for relacion in fase.asociacionTipoItem:
			if relacion.tipoItem in lista_tipos_roles:
				var= dict(id= relacion.right_id, nombreTipoItem= relacion.tipoItem.getNombre())
				lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_no_tipo_items_por_fase(request):
	session = DBSession()
	lista= []
	id_fase= request.matchdict['id_fase']
	fase= session.query(Fase).filter_by(id = id_fase).first()
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	if fase != None:
		proyecto= session.query(Proyecto).filter_by(id = fase.proyecto_id).first()
		lista_vista= []
		lista_no_asignados= []
		"""
		tipos de items asiganados a la fase
		"""
		for relacion in fase.asociacionTipoItem:
			lista_vista.append(relacion.tipoItem)
		"""
		tipos de items pertenecients al proyecto
		"""
		for tipo in proyecto.tipoItems:
			if not(tipo in lista_vista):
				lista_no_asignados.append(tipo)
		"""
		note: extrae todos los tipos de items que se encuentran en los 
		roles de los usuarios
		"""
		###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
		en_linea= authenticated_userid(request)
		usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
		lista_tipos_roles= []
		if usuario.esLider(proyecto):
			for tipoItem in proyecto.tipoItems:
				lista_tipos_roles.append(tipoItem)
		for asociacion in usuario.asociacionRol:
			rol= asociacion.rol
			for relacion in rol.asociacionTipoItem:
				tipoItem= relacion.tipoItem
				if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
					lista_tipos_roles.append(tipoItem)
		######
		for tipo in lista_no_asignados:
			if tipo in lista_tipos_roles:
				var= dict(id= tipo.id, nombreTipoItem= tipo.getNombre())
				lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_no_fases_por_proyecto(request):
	session = DBSession()
	lista= []
	lista_vista= []
	lista_excluidos= []
	id_Proyecto = request.matchdict['id_proyecto']
	proyecto= session.query(Proyecto).filter_by(id = id_Proyecto).first()
	if proyecto != None:
		for fase in proyecto.fases:
			lista_vista.append(fase)
		for fase in session.query(Fase).all():
			if not (fase in lista_vista):
				lista_excluidos.append(fase)
		for fase in lista_excluidos:
			proyecto= session.query(Proyecto).filter_by(id = fase.proyecto_id).first()
			var= dict(id= fase.id, nombreFase= proyecto.getNombre() + " - " + fase.getNombre())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_items_por_fases(request):
	session = DBSession()
	lista= []
	idFase = request.matchdict['idFase']
	lista_tipos_roles= []
	tipos_asociado_fase= []
	fase= session.query(Fase).filter_by(id = idFase).first()
	proyecto= session.query(Proyecto).filter_by(id = fase.proyecto_id).first()
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	for relacion in fase.asociacionTipoItem:
		tipos_asociado_fase.append(relacion.tipoItem)
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	for item in fase.items:
		if (item.tipoItem in lista_tipos_roles) and (item.tipoItem in tipos_asociado_fase) and item.getEstado() != 'Eliminado':
			var= dict(id= item.id, nombre= item.getNombre(),version= item.getVersion(), numero= item.getNumero(), numeroTipoItem= item.getNumeroTipoItem(), tipoItem= item.getTipoItem(),
			complejidad= item.getComplejidad(), descripcion= item.getDescripcion(), estado= item.getEstado())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)



def buscar_items_por_fases(request):
	session = DBSession()
	lista= []
	idFase= int(request.matchdict['idFase'])
	nombre= request.matchdict['nombre']
	complejidad= int(request.matchdict['complejidad'])
	version= int(request.matchdict['version'])
	estado= request.matchdict['estado']
	lista_tipos_roles= []
	tipos_asociado_fase= []
	fase= session.query(Fase).filter_by(id = idFase).first()
	proyecto= session.query(Proyecto).filter_by(id = fase.proyecto_id).first()
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	for relacion in fase.asociacionTipoItem:
		tipos_asociado_fase.append(relacion.tipoItem)
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	for item in fase.items:
		if (item.tipoItem in lista_tipos_roles) and (item.tipoItem in tipos_asociado_fase) and (item.getEstado() == estado or item.getVersion() == version or item.getNombre() == nombre or item.getComplejidad() == complejidad):
			var= dict(id= item.id, nombre= item.getNombre(),version= item.getVersion(), numero= item.getNumero(), numeroTipoItem= item.getNumeroTipoItem(), tipoItem= item.getTipoItem(),
			complejidad= item.getComplejidad(), descripcion= item.getDescripcion(), estado= item.getEstado())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)

def listarVersionesAnteriores_Revertir(request):
	session = DBSession()
	lista= []
	versiones= []
	idItem= request.matchdict['idItem']
	item= session.query(Item).filter_by(id= idItem).first()
	"""
	note: extrae las versiones anteriores de cada item
	"""
	while len(item.versionAnterior) > 0:
		versiones.append(item.versionAnterior[0])
		item= item.versionAnterior[0]
	"""
	note: envia a la aplicacion extjs las versiones anteriores del item seleccionado
	"""
	for item in versiones:
		var= dict(id= item.id, nombre= item.getNombre(), version= item.getVersion(), numero= item.getNumero(), numeroTipoItem= item.getNumeroTipoItem(), tipoItem= item.getTipoItem(),
		complejidad= item.getComplejidad(), descripcion= item.getDescripcion(), estado= item.getEstado())
		lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_antecesor(request):
	session = DBSession()
	lista= []
	idItem= request.matchdict['idItem']
	item= session.query(Item).filter_by(id= idItem).first()
	fase= session.query(Fase).filter_by(id= item.fase_id).first()
	proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first()
	ubicacion= proyecto.fases.index(fase)
	if ubicacion == 0:
		output = json.dumps({'data':lista})
		return Response(output)
	else:
		faseAnterior= proyecto.fases[ubicacion-1]
		###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
		en_linea= authenticated_userid(request)
		usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
		tipos_asociado_fase= []
		lista_tipos_roles= []
		for relacion in faseAnterior.asociacionTipoItem:
			tipos_asociado_fase.append(relacion.tipoItem)
		if usuario.esLider(proyecto):
			for tipoItem in proyecto.tipoItems:
				lista_tipos_roles.append(tipoItem)
		for asociacion in usuario.asociacionRol:
			rol= asociacion.rol
			for relacion in rol.asociacionTipoItem:
				tipoItem= relacion.tipoItem
				if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
					lista_tipos_roles.append(tipoItem)
		######
		for item_aux in faseAnterior.items:
			if item_aux.getEstado() != 'Eliminado' and (item_aux.tipoItem in tipos_asociado_fase) and (item_aux.tipoItem in lista_tipos_roles):
				relaciona= False
				for relacion in item_aux.relacionSucesor:
					if relacion.item == item:
						relaciona= True
				if relaciona:
					var= dict(id= item_aux.id, nombreItem= item_aux.getNombre())
					lista.append(var)
		output = json.dumps({'data':lista})
	return Response(output)


def listar_items_fase_ant(request):
	session = DBSession()
	lista= []
	lista_aux= []
	idItem= request.matchdict['idItem']
	item= session.query(Item).filter_by(id= idItem).first()
	fase= session.query(Fase).filter_by(id= item.fase_id).first()
	proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first()
	ubicacion= proyecto.fases.index(fase)
	if ubicacion == 0:
		output = json.dumps({'data':lista})
		return Response(output)
	else:
		faseAnterior= proyecto.fases[ubicacion-1]
		###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
		en_linea= authenticated_userid(request)
		usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
		tipos_asociado_fase= []
		lista_tipos_roles= []
		for relacion in faseAnterior.asociacionTipoItem:
			tipos_asociado_fase.append(relacion.tipoItem)
		if usuario.esLider(proyecto):
			for tipoItem in proyecto.tipoItems:
				lista_tipos_roles.append(tipoItem)
		for asociacion in usuario.asociacionRol:
			rol= asociacion.rol
			for relacion in rol.asociacionTipoItem:
				tipoItem= relacion.tipoItem
				if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
					lista_tipos_roles.append(tipoItem)
		######
		for item_aux in faseAnterior.items:
			if item_aux.getEstado() != 'Eliminado' and (item_aux.tipoItem in tipos_asociado_fase) and (item_aux.tipoItem in lista_tipos_roles):
				relaciona= False
				for relacion in item_aux.relacionSucesor:
					if relacion.item == item:
						relaciona= True
				if not(relaciona):
					var= dict(id= item_aux.id, nombreItem= item_aux.getNombre())
					lista.append(var)
		output = json.dumps({'data':lista})
	return Response(output)


def listar_padre(request):
	session = DBSession()
	lista= []
	idItem= request.matchdict['idItem']
	item= session.query(Item).filter_by(id= idItem).first()
	fase= session.query(Fase).filter_by(id= item.fase_id).first()
	proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first()
	###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	tipos_asociado_fase= []
	lista_tipos_roles= []
	for relacion in fase.asociacionTipoItem:
		tipos_asociado_fase.append(relacion.tipoItem)
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	######
	for item_aux in fase.items:
		if item_aux != item and item_aux.getEstado() != 'Eliminado' and (item_aux.tipoItem in lista_tipos_roles) and (item_aux.tipoItem in tipos_asociado_fase):
			relaciona= False
			for relacion in item_aux.relacionHijo:
				if relacion.hijo == item:
					relaciona= True
			if relaciona:
				var= dict(id= item_aux.id, nombreItem= item_aux.getNombre())
				lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_items_fase(request):
	session = DBSession()
	lista= []
	idItem= request.matchdict['idItem']
	item= session.query(Item).filter_by(id= idItem).first()
	fase= session.query(Fase).filter_by(id= item.fase_id).first()
	proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first()
	###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	tipos_asociado_fase= []
	lista_tipos_roles= []
	for relacion in fase.asociacionTipoItem:
		tipos_asociado_fase.append(relacion.tipoItem)
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	######
	for item_aux in fase.items:
		if item_aux != item and item_aux.getEstado() != 'Eliminado' and (item_aux.tipoItem in lista_tipos_roles) and (item_aux.tipoItem in tipos_asociado_fase):
			relaciona= False
			for relacion in item_aux.relacionHijo:
				if relacion.hijo == item:
					relaciona= True
			if not(relaciona):
				var= dict(id= item_aux.id, nombreItem= item_aux.getNombre())
				lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_historial_item(request):
	session = DBSession()
	lista= []
	lista_versiones= []
	idItem= request.matchdict['idItem']
	item= session.query(Item).filter_by(id= idItem).first()
	item1= item
	item2= item
	"""
	note: historial de antecesores
	"""
	while item1.tieneVersionAnterior():
		lista_versiones.append(item1.getVersionAnterior())
		item1= item1.getVersionAnterior()
	"""
	note: historial de sucesores
	"""
	while item2.tieneVersionSuperior():
		lista_versiones.append(item2.getVersionSuperior(session))
		item2= item2.getVersionSuperior(session)
	"""
	note: el item actual tambien se anhade
	"""
	lista_versiones.append(item)
	for version in lista_versiones:
		historias= session.query(Historial).filter_by(item_id= version.id).all()
		for historia in historias:
			var= dict(id= historia.id, nombreItem= historia.item.getNombre(), version= historia.item.getVersion() ,descripcion= historia.getDescripcion(), fecha= historia.getFecha(),nombreUsuario= historia.usuario.getNombreUsuario(), estado= historia.item.getEstado())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)


def listar_items_eliminados(request):
	session = DBSession()
	lista= []
	idFase = request.matchdict['idFase']
	fase= session.query(Fase).filter_by(id = idFase).first()
	proyecto= session.query(Proyecto).filter_by(id = fase.proyecto_id).first()
	###### segmento de codigo que recopila los tipos de item de acuerdo al rol del usuario
	en_linea= authenticated_userid(request)
	usuario= session.query(Usuario).filter_by(nombreUsuario= en_linea).first()
	tipos_asociado_fase= []
	lista_tipos_roles= []
	for relacion in fase.asociacionTipoItem:
		tipos_asociado_fase.append(relacion.tipoItem)
	if usuario.esLider(proyecto):
		for tipoItem in proyecto.tipoItems:
			lista_tipos_roles.append(tipoItem)
	for asociacion in usuario.asociacionRol:
		rol= asociacion.rol
		for relacion in rol.asociacionTipoItem:
			tipoItem= relacion.tipoItem
			if not(tipoItem in lista_tipos_roles) and (tipoItem in proyecto.tipoItems):
				lista_tipos_roles.append(tipoItem)
	######
	for item in fase.items:
		if item.getEstado() == 'Eliminado' and (item.tipoItem in lista_tipos_roles) and (item.tipoItem in tipos_asociado_fase):
			var= dict(id= item.id, nombre= item.getNombre(),version= item.getVersion(), numero= item.getNumero(), numeroTipoItem= item.getNumeroTipoItem(), tipoItem= item.getTipoItem(),
			complejidad= item.getComplejidad(), descripcion= item.getDescripcion(), estado= item.getEstado())
			lista.append(var)
	output = json.dumps({'data':lista})
	return Response(output)
